﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 战斗系统原型.战斗系统
{
    public class 战斗选项卡
    {
        public class 选项组
        {
            public string 选项组名称 { get; set; } = "默认选项组";
            public List<选项> 选项列表 { get; set; } = new();

        }

        public class 选项
        {
            public virtual string 选项名称 { get; set; } = "默认选项";
            public virtual object 储存类型 { get; set; } = new();
            public enum 选项类型 { 子菜单选项, 命令选项 }
            public virtual bool 拥有子选项 { get; set; } = false;
            public virtual bool 兼容所有角色 { get; set; } = true;
            public virtual List<角色> 兼容角色 { get; set; } = new();
            public virtual 选项组? 子选项组 { get; set; }
            public virtual void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                if (子选项组 == null)
                {
                    显示.日志输出(显示.日志类型.中断, "没有子菜单且没有配置选项要执行的内容");
                    return;
                }
                显示.日志输出(显示.日志类型.中断, "没有有菜单但没有配置菜单逻辑");
                return;
            }
            public virtual void 刷新菜单(角色 使用角色, 战场属性 战场, object 储存类型)
            {
            }

        }

        public class 待攻击对象 : 选项
        {
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 被攻击角色)
            {
                使用角色.物理攻击(使用角色, (角色)被攻击角色, 战场);
                战场.下一行动!(战场, 战场.队伍数据!);
            }
        }

        public class 菜单_战斗 : 选项
        {
            public override bool 拥有子选项 { get; set; } = true;
            public override string 选项名称 { get; set; } = 战斗选项.战斗.ToString();
            public override 选项组? 子选项组 { get; set; } = new();
            public override void 刷新菜单(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                玩家操作(使用角色, 战场);
            }
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                if (使用角色.操作模式 == 角色.操作者.玩家)
                {
                    玩家操作(使用角色, 战场);
                }
                if (使用角色.操作模式 == 角色.操作者.AI)
                {
                    AI操作(使用角色, 战场);
                }
            }

            public void 玩家操作(角色 使用角色, 战场属性 战场)
            {
                if (战场.行动条.Count <= 0) { 显示.日志输出(显示.日志类型.中断, "行动条为空，无法继续操作，请检查行动条状态"); return; }
                子选项组!.选项列表.Clear();
                //将所有敌方角色加入角色组
                var 敌方角色组 = 战场.队伍数据![队伍类型.敌方队伍].队伍成员;
                foreach (var 敌方角色 in 敌方角色组)
                {
                    if (敌方角色.角色状态 != 角色.状态.正常) { continue; }
                    子选项组.选项列表.Add
                     (
                        new 待攻击对象()
                        {
                            选项名称 = 敌方角色.角色名称,
                            储存类型 = 敌方角色,//临时储存敌方角色
                        }
                     );
                }
            }

            private void AI操作(角色 使用角色, 战场属性 战场)
            {
                throw new NotImplementedException();
            }


        }
        public class 菜单_防御 : 选项
        {
            public override bool 拥有子选项 { get; set; } = false;
            public override string 选项名称 { get; set; } = 战斗选项.防御.ToString();
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                if (战场.下一行动 != null && 战场.队伍数据 != null)
                {
                    战场.下一行动(战场, 战场.队伍数据);
                    战场.日志.Add($"{使用角色} 防御敌人攻击");
                }
            }
        }

        public class 菜单_物品 : 选项
        {
            public override bool 拥有子选项 { get; set; } = true;
            public override string 选项名称 { get; set; } = 战斗选项.物品.ToString();
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                if (战场.队伍数据 == null) { 显示.日志输出(显示.日志类型.中断, "无法获取到队伍信息"); return; }
                if (!战场.队伍数据.ContainsKey(队伍类型.我方队伍)) { 显示.日志输出(显示.日志类型.中断, "无法获取到我方队伍"); return; }
                foreach (var 物品 in 战场.队伍数据[队伍类型.我方队伍].物品列表)
                {
                    if (子选项组 == null) { 子选项组 = new 选项组(); }
                    子选项组.选项组名称 = "物品列表";
                    子选项组.选项列表.Add(new 战斗物品选项()
                    {
                        对应物品 = 物品,
                        选项名称 = 物品.名称,
                    });
                }

            }

            public 选项组 获取物品表菜单()
            {
                if (子选项组 != null && 子选项组.选项列表 != null && 子选项组.选项列表.Count != 0)
                {
                    return 子选项组;
                }
                else
                {
                    return new 选项组() { 选项组名称 = "列表为空" };
                }

            }

        }

        public class 战斗物品选项 : 选项
        {
            public 物品? 对应物品 { get; set; }
            public override bool 拥有子选项 { get; set; } = false;
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                base.执行选项(使用角色, 战场, 储存类型);
            }
        }

        public class 菜单_符卡与符术 : 选项
        {
            public override string 选项名称 { get; set; } = 战斗选项.符卡与符术.ToString();
            public override 选项组? 子选项组 { get; set; } = new();
            public override bool 拥有子选项 { get; set; } = true;
            public override void 执行选项(角色 使用角色, 战场属性 战场, object 储存类型)
            {
                if (使用角色.操作模式 == 角色.操作者.玩家)
                {
                    玩家操作(使用角色, 战场);
                }
                if (使用角色.操作模式 == 角色.操作者.AI)
                {
                    AI操作(使用角色, 战场);
                }
            }

            public void 玩家操作(角色 使用角色, 战场属性 战场)
            {
                if (战场.行动条.Count <= 0) { 显示.日志输出(显示.日志类型.中断, "行动条为空，无法继续操作，请检查行动条状态"); return; }
                //将所有敌方角色加入角色组
                var 敌方角色组 = 战场.行动条[0].FindAll(角色 => 角色.操作模式 == 角色.操作者.AI);
                foreach (var 敌方角色 in 敌方角色组)
                {
                    子选项组!.选项列表.Add
                     (
                        new 待攻击对象()
                        {
                            选项名称 = 敌方角色.角色名称,
                            储存类型 = 敌方角色,//临时储存敌方角色
                        }
                     );
                }
            }

            private void AI操作(角色 使用角色, 战场属性 战场)
            {
                throw new NotImplementedException();
            }
        }
    }
}
